最近想深入的理解一下java 的工作机制，也是便于后期的面试。

1、A：HashMap和Hashtable有什么区别？

    Q：HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点：

　   　HashMap允许键和值是null，而Hashtable不允许键或者值是null。

　　   Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。

　  　 我们再来剖析一下这个问题，如果你答些，面试官几乎不会满意的，下面我来深入的看一下，具体的细节和延伸

　　  1,看一下什么是Map，Map是一个接口，在 api 中的定义为

An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

　　  翻译软件译文为：将键映射到值的对象。映射不能包含重复的键；每个键最多可以映射到一个值。也就是说Map是一个不能重复键的键值对接口。

　　  我们再来看一下Map源码：

/* * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */package java.util;import java.util.function.BiConsumer;import java.util.function.BiFunction;import java.util.function.Function;import java.io.Serializable;/** * An object that maps keys to values.  A map cannot contain duplicate keys; * each key can map to at most one value. * * 
This interface takes the place of the Dictionary class, which * was a totally abstract class rather than an interface. * * 
The Map interface provides three collection views, which * allow a map's contents to be viewed as a set of keys, collection of values, * or set of key-value mappings.  The order of a map is defined as * the order in which the iterators on the map's collection views return their * elements.  Some map implementations, like the TreeMap class, make * specific guarantees as to their order; others, like the HashMap * class, do not. * * 
Note: great care must be exercised if mutable objects are used as map * keys.  The behavior of a map is not specified if the value of an object is * changed in a manner that affects equals comparisons while the * object is a key in the map.  A special case of this prohibition is that it * is not permissible for a map to contain itself as a key.  While it is * permissible for a map to contain itself as a value, extreme caution is * advised: the equals and hashCode methods are no longer * well defined on such a map. * * 
All general-purpose map implementation classes should provide two * "standard" constructors: a void (no arguments) constructor which creates an * empty map, and a constructor with a single argument of type Map, * which creates a new map with the same key-value mappings as its argument. * In effect, the latter constructor allows the user to copy any map, * producing an equivalent map of the desired class.  There is no way to * enforce this recommendation (as interfaces cannot contain constructors) but * all of the general-purpose map implementations in the JDK comply. * * 
The "destructive" methods contained in this interface, that is, the * methods that modify the map on which they operate, are specified to throw * UnsupportedOperationException if this map does not support the * operation.  If this is the case, these methods may, but are not required * to, throw an UnsupportedOperationException if the invocation would * have no effect on the map.  For example, invoking the {
     @link #putAll(Map)} * method on an unmodifiable map may, but is not required to, throw the * exception if the map whose mappings are to be "superimposed" is empty. * * 
Some map implementations have restrictions on the keys and values they * may contain.  For example, some implementations prohibit null keys and * values, and some have restrictions on the types of their keys.  Attempting * to insert an ineligible key or value throws an unchecked exception, * typically NullPointerException or ClassCastException. * Attempting to query the presence of an ineligible key or value may throw an * exception, or it may simply return false; some implementations will exhibit * the former behavior and some will exhibit the latter.  More generally, * attempting an operation on an ineligible key or value whose completion * would not result in the insertion of an ineligible element into the map may * throw an exception or it may succeed, at the option of the implementation. * Such exceptions are marked as "optional" in the specification for this * interface. * * 
Many methods in Collections Framework interfaces are defined * in terms of the {
     @link Object#equals(Object) equals} method.  For * example, the specification for the {
     @link #containsKey(Object) * containsKey(Object key)} method says: "returns true if and * only if this map contains a mapping for a key k such that * (key==null ? k==null : key.equals(k))." This specification should * not be construed to imply that invoking Map.containsKey * with a non-null argument key will cause key.equals(k) to * be invoked for any key k.  Implementations are free to * implement optimizations whereby the equals invocation is avoided, * for example, by first comparing the hash codes of the two keys.  (The * {
     @link Object#hashCode()} specification guarantees that two objects with * unequal hash codes cannot be equal.)  More generally, implementations of * the various Collections Framework interfaces are free to take advantage of * the specified behavior of underlying {
     @link Object} methods wherever the * implementor deems it appropriate. * * 
Some map operations which perform recursive traversal of the map may fail * with an exception for self-referential instances where the map directly or * indirectly contains itself. This includes the {
     @code clone()}, * {
     @code equals()}, {
     @code hashCode()} and {
     @code toString()} methods. * Implementations may optionally handle the self-referential scenario, however * most current implementations do not do so. * * 
This interface is a member of the *  * Java Collections Framework. * * @param 
       
         the type of keys maintained by this map * @param 
        
          the type of mapped values * * @author  Josh Bloch * @see HashMap * @see TreeMap * @see Hashtable * @see SortedMap * @see Collection * @see Set * @since 1.2 */public interface Map
         
           {    // Query Operations    /**     * Returns the number of key-value mappings in this map.  If the     * map contains more than 
          Integer.MAX_VALUE elements, returns     * 
          Integer.MAX_VALUE.     *     * @return the number of key-value mappings in this map     */    int size();    /**     * Returns 
          true if this map contains no key-value mappings.     *     * @return 
          true if this map contains no key-value mappings     */    boolean isEmpty();    /**     * Returns 
          true if this map contains a mapping for the specified     * key.  More formally, returns 
          true if and only if     * this map contains a mapping for a key 
          k such that     * 
          (key==null ? k==null : key.equals(k)).  (There can be     * at most one such mapping.)     *     * @param key key whose presence in this map is to be tested     * @return 
          true if this map contains a mapping for the specified     *         key     * @throws ClassCastException if the key is of an inappropriate type for     *         this map     * (
          optional)     * @throws NullPointerException if the specified key is null and this map     *         does not permit null keys     * (
          optional)     */    boolean containsKey(Object key);    /**     * Returns 
          true if this map maps one or more keys to the     * specified value.  More formally, returns 
          true if and only if     * this map contains at least one mapping to a value 
          v such that     * 
          (value==null ? v==null : value.equals(v)).  This operation     * will probably require time linear in the map size for most     * implementations of the 
          Map interface.     *     * @param value value whose presence in this map is to be tested     * @return 
          true if this map maps one or more keys to the     *         specified value     * @throws ClassCastException if the value is of an inappropriate type for     *         this map     * (
          optional)     * @throws NullPointerException if the specified value is null and this     *         map does not permit null values     * (
          optional)     */    boolean containsValue(Object value);    /**     * Returns the value to which the specified key is mapped,     * or {
     @code null} if this map contains no mapping for the key.     *     * 
         
        
       
More formally, if this map contains a mapping from a key     * {
     @code k} to a value {
     @code v} such that {
     @code (key==null ? k==null :     * key.equals(k))}, then this method returns {
     @code v}; otherwise     * it returns {
     @code null}.  (There can be at most one such mapping.)     *     * 
If this map permits null values, then a return value of     * {
     @code null} does not necessarily indicate that the map     * contains no mapping for the key; it's also possible that the map     * explicitly maps the key to {
     @code null}.  The {
     @link #containsKey     * containsKey} operation may be used to distinguish these two cases.     *     * @param key the key whose associated value is to be returned     * @return the value to which the specified key is mapped, or     *         {
     @code null} if this map contains no mapping for the key     * @throws ClassCastException if the key is of an inappropriate type for     *         this map     * (optional)     * @throws NullPointerException if the specified key is null and this map     *         does not permit null keys     * (optional)     */    V get(Object key);    // Modification Operations    /**     * Associates the specified value with the specified key in this map     * (optional operation).  If the map previously contained a mapping for     * the key, the old value is replaced by the specified value.  (A map     * m is said to contain a mapping for a key k if and only     * if {
     @link #containsKey(Object) m.containsKey(k)} would return     * true.)     *     * @param key key with which the specified value is to be associated     * @param value value to be associated with the specified key     * @return the previous value associated with key, or     *         null if there was no mapping for key.     *         (A null return can also indicate that the map     *         previously associated null with key,     *         if the implementation supports null values.)     * @throws UnsupportedOperationException if the put operation     *         is not supported by this map     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     * @throws NullPointerException if the specified key or value is null     *         and this map does not permit null keys or values     * @throws IllegalArgumentException if some property of the specified key     *         or value prevents it from being stored in this map     */    V put(K key, V value);    /**     * Removes the mapping for a key from this map if it is present     * (optional operation).   More formally, if this map contains a mapping     * from key k to value v such that     * (key==null ?  k==null : key.equals(k)), that mapping     * is removed.  (The map can contain at most one such mapping.)     *     * 
Returns the value to which this map previously associated the key,     * or null if the map contained no mapping for the key.     *     * 
If this map permits null values, then a return value of     * null does not necessarily indicate that the map     * contained no mapping for the key; it's also possible that the map     * explicitly mapped the key to null.     *     * 
The map will not contain a mapping for the specified key once the     * call returns.     *     * @param key key whose mapping is to be removed from the map     * @return the previous value associated with key, or     *         null if there was no mapping for key.     * @throws UnsupportedOperationException if the remove operation     *         is not supported by this map     * @throws ClassCastException if the key is of an inappropriate type for     *         this map     * (optional)     * @throws NullPointerException if the specified key is null and this     *         map does not permit null keys     * (optional)     */    V remove(Object key);    // Bulk Operations    /**     * Copies all of the mappings from the specified map to this map     * (optional operation).  The effect of this call is equivalent to that     * of calling {
     @link #put(Object,Object) put(k, v)} on this map once     * for each mapping from key k to value v in the     * specified map.  The behavior of this operation is undefined if the     * specified map is modified while the operation is in progress.     *     * @param m mappings to be stored in this map     * @throws UnsupportedOperationException if the putAll operation     *         is not supported by this map     * @throws ClassCastException if the class of a key or value in the     *         specified map prevents it from being stored in this map     * @throws NullPointerException if the specified map is null, or if     *         this map does not permit null keys or values, and the     *         specified map contains null keys or values     * @throws IllegalArgumentException if some property of a key or value in     *         the specified map prevents it from being stored in this map     */    void putAll(Map
        m);    /**     * Removes all of the mappings from this map (optional operation).     * The map will be empty after this call returns.     *     * @throws UnsupportedOperationException if the clear operation     *         is not supported by this map     */    void clear();    // Views    /**     * Returns a {
     @link Set} view of the keys contained in this map.     * The set is backed by the map, so changes to the map are     * reflected in the set, and vice-versa.  If the map is modified     * while an iteration over the set is in progress (except through     * the iterator's own remove operation), the results of     * the iteration are undefined.  The set supports element removal,     * which removes the corresponding mapping from the map, via the     * Iterator.remove, Set.remove,     * removeAll, retainAll, and clear     * operations.  It does not support the add or addAll     * operations.     *     * @return a set view of the keys contained in this map     */    Set
       
         keySet();    /**     * Returns a {
     @link Collection} view of the values contained in this map.     * The collection is backed by the map, so changes to the map are     * reflected in the collection, and vice-versa.  If the map is     * modified while an iteration over the collection is in progress     * (except through the iterator's own 
        remove operation),     * the results of the iteration are undefined.  The collection     * supports element removal, which removes the corresponding     * mapping from the map, via the 
        Iterator.remove,     * 
        Collection.remove, 
        removeAll,     * 
        retainAll and 
        clear operations.  It does not     * support the 
        add or 
        addAll operations.     *     * @return a collection view of the values contained in this map     */    Collection
        
          values();    /**     * Returns a {
     @link Set} view of the mappings contained in this map.     * The set is backed by the map, so changes to the map are     * reflected in the set, and vice-versa.  If the map is modified     * while an iteration over the set is in progress (except through     * the iterator's own 
         remove operation, or through the     * 
         setValue operation on a map entry returned by the     * iterator) the results of the iteration are undefined.  The set     * supports element removal, which removes the corresponding     * mapping from the map, via the 
         Iterator.remove,     * 
         Set.remove, 
         removeAll, 
         retainAll and     * 
         clear operations.  It does not support the     * 
         add or 
         addAll operations.     *     * @return a set view of the mappings contained in this map     */    Set
         
          
           > entrySet();    /**     * A map entry (key-value pair).  The 
           Map.entrySet method returns     * a collection-view of the map, whose elements are of this class.  The     * 
           only way to obtain a reference to a map entry is from the     * iterator of this collection-view.  These 
           Map.Entry objects are     * valid 
           only for the duration of the iteration; more formally,     * the behavior of a map entry is undefined if the backing map has been     * modified after the entry was returned by the iterator, except through     * the 
           setValue operation on the map entry.     *     * @see Map#entrySet()     * @since 1.2     */    interface Entry
           
             { /** * Returns the key corresponding to this entry. * * @return the key corresponding to this entry * @throws IllegalStateException implementations may, but are not * required to, throw this exception if the entry has been * removed from the backing map. */ K getKey(); /** * Returns the value corresponding to this entry. If the mapping * has been removed from the backing map (by the iterator's * 
            remove operation), the results of this call are undefined. * * @return the value corresponding to this entry * @throws IllegalStateException implementations may, but are not * required to, throw this exception if the entry has been * removed from the backing map. */ V getValue(); /** * Replaces the value corresponding to this entry with the specified * value (optional operation). (Writes through to the map.) The * behavior of this call is undefined if the mapping has already been * removed from the map (by the iterator's 
            remove operation). * * @param value new value to be stored in this entry * @return old value corresponding to the entry * @throws UnsupportedOperationException if the 
            put operation * is not supported by the backing map * @throws ClassCastException if the class of the specified value * prevents it from being stored in the backing map * @throws NullPointerException if the backing map does not permit * null values, and the specified value is null * @throws IllegalArgumentException if some property of this value * prevents it from being stored in the backing map * @throws IllegalStateException implementations may, but are not * required to, throw this exception if the entry has been * removed from the backing map. */ V setValue(V value); /** * Compares the specified object with this entry for equality. * Returns 
            true if the given object is also a map entry and * the two entries represent the same mapping. More formally, two * entries 
            e1 and 
            e2 represent the same mapping * if
           
          
         
        
       
         *     (e1.getKey()==null ?         *      e2.getKey()==null : e1.getKey().equals(e2.getKey()))  &&         *     (e1.getValue()==null ?         *      e2.getValue()==null : e1.getValue().equals(e2.getValue()))         * 
         * This ensures that the equals method works properly across         * different implementations of the Map.Entry interface.         *         * @param o object to be compared for equality with this map entry         * @return true if the specified object is equal to this map         *         entry         */        boolean equals(Object o);        /**         * Returns the hash code value for this map entry.  The hash code         * of a map entry e is defined to be: 
         *     (e.getKey()==null   ? 0 : e.getKey().hashCode()) ^         *     (e.getValue()==null ? 0 : e.getValue().hashCode())         * 
         * This ensures that e1.equals(e2) implies that         * e1.hashCode()==e2.hashCode() for any two Entries         * e1 and e2, as required by the general         * contract of Object.hashCode.         *         * @return the hash code value for this map entry         * @see Object#hashCode()         * @see Object#equals(Object)         * @see #equals(Object)         */        int hashCode();        /**         * Returns a comparator that compares {
     @link Map.Entry} in natural order on key.         *         * 
The returned comparator is serializable and throws {
     @link         * NullPointerException} when comparing an entry with a null key.         *         * @param  
       
         the {
     @link Comparable} type of then map keys         * @param  
        
          the type of the map values         * @return a comparator that compares {
     @link Map.Entry} in natural order on key.         * @see Comparable         * @since 1.8         */        public static 
         
          , V> Comparator
          
           
            > comparingByKey() { return (Comparator
            
             
              > & Serializable) (c1, c2) -> c1.getKey().compareTo(c2.getKey()); } /** * Returns a comparator that compares { @link Map.Entry} in natural order on value. * * 
             
            
           
          
         
        
       
The returned comparator is serializable and throws {
     @link         * NullPointerException} when comparing an entry with null values.         *         * @param 
       
         the type of the map keys         * @param 
        
          the {
     @link Comparable} type of the map values         * @return a comparator that compares {
     @link Map.Entry} in natural order on value.         * @see Comparable         * @since 1.8         */        public static 
         
          > Comparator
          
           
            > comparingByValue() { return (Comparator
            
             
              > & Serializable) (c1, c2) -> c1.getValue().compareTo(c2.getValue()); } /** * Returns a comparator that compares { @link Map.Entry} by key using the given * { @link Comparator}. * * 
             
            
           
          
         
        
       
The returned comparator is serializable if the specified comparator         * is also serializable.         *         * @param  
       
         the type of the map keys         * @param  
        
          the type of the map values         * @param  cmp the key {
     @link Comparator}         * @return a comparator that compares {
     @link Map.Entry} by the key.         * @since 1.8         */        public static 
         
           Comparator
          
           
            > comparingByKey(Comparator
             cmp) { Objects.requireNonNull(cmp); return (Comparator
            
             
              > & Serializable) (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey()); } /** * Returns a comparator that compares { @link Map.Entry} by value using the given * { @link Comparator}. * * 
             
            
           
          
         
        
       
The returned comparator is serializable if the specified comparator         * is also serializable.         *         * @param  
       
         the type of the map keys         * @param  
        
          the type of the map values         * @param  cmp the value {
     @link Comparator}         * @return a comparator that compares {
     @link Map.Entry} by the value.         * @since 1.8         */        public static 
         
           Comparator
          
           
            > comparingByValue(Comparator
             cmp) { Objects.requireNonNull(cmp); return (Comparator
            
             
              > & Serializable) (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue()); } } // Comparison and hashing /** * Compares the specified object with this map for equality. Returns * 
              true if the given object is also a map and the two maps * represent the same mappings. More formally, two maps 
              m1 and * 
              m2 represent the same mappings if * 
              m1.entrySet().equals(m2.entrySet()). This ensures that the * 
              equals method works properly across different implementations * of the 
              Map interface. * * @param o object to be compared for equality with this map * @return 
              true if the specified object is equal to this map */ boolean equals(Object o); /** * Returns the hash code value for this map. The hash code of a map is * defined to be the sum of the hash codes of each entry in the map's * 
              entrySet() view. This ensures that 
              m1.equals(m2) * implies that 
              m1.hashCode()==m2.hashCode() for any two maps * 
              m1 and 
              m2, as required by the general contract of * { @link Object#hashCode}. * * @return the hash code value for this map * @see Map.Entry#hashCode() * @see Object#equals(Object) * @see #equals(Object) */ int hashCode(); // Defaultable methods /** * Returns the value to which the specified key is mapped, or * { @code defaultValue} if this map contains no mapping for the key. * * @implSpec * The default implementation makes no guarantees about synchronization * or atomicity properties of this method. Any implementation providing * atomicity guarantees must override this method and document its * concurrency properties. * * @param key the key whose associated value is to be returned * @param defaultValue the default mapping of the key * @return the value to which the specified key is mapped, or * { @code defaultValue} if this map contains no mapping for the key * @throws ClassCastException if the key is of an inappropriate type for * this map * (
              optional) * @throws NullPointerException if the specified key is null and this map * does not permit null keys * (
              optional) * @since 1.8 */ default V getOrDefault(Object key, V defaultValue) { V v; return (((v = get(key)) != null) || containsKey(key)) ? v : defaultValue; } /** * Performs the given action for each entry in this map until all entries * have been processed or the action throws an exception. Unless * otherwise specified by the implementing class, actions are performed in * the order of entry set iteration (if an iteration order is specified.) * Exceptions thrown by the action are relayed to the caller. * * @implSpec * The default implementation is equivalent to, for this { @code map}: * 
             
            
           
          
         
        
       
 {
     @code     * for (Map.Entry
       
         entry : map.entrySet())     *     action.accept(entry.getKey(), entry.getValue());     * }
       
     *     * The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.     *     * @param action The action to be performed for each entry     * @throws NullPointerException if the specified action is null     * @throws ConcurrentModificationException if an entry is found to be     * removed during iteration     * @since 1.8     */    default void forEach(BiConsumer
       action) {        Objects.requireNonNull(action);        for (Map.Entry
      
        entry : entrySet()) {            K k;            V v;            try {                k = entry.getKey();                v = entry.getValue();            } catch(IllegalStateException ise) {                // this usually means the entry is no longer in the map.                throw new ConcurrentModificationException(ise);            }            action.accept(k, v);        }    }    /**     * Replaces each entry's value with the result of invoking the given     * function on that entry until all entries have been processed or the     * function throws an exception.  Exceptions thrown by the function are     * relayed to the caller.     *     * @implSpec     * 
       
The default implementation is equivalent to, for this {
     @code map}:     * 
       
 {
     @code     * for (Map.Entry
        
          entry : map.entrySet())     *     entry.setValue(function.apply(entry.getKey(), entry.getValue()));     * }
        
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.     *     * @param function the function to apply to each entry     * @throws UnsupportedOperationException if the {
     @code set} operation     * is not supported by this map's entry set iterator.     * @throws ClassCastException if the class of a replacement value     * prevents it from being stored in this map     * @throws NullPointerException if the specified function is null, or the     * specified replacement value is null, and this map does not permit null     * values     * @throws ClassCastException if a replacement value is of an inappropriate     *         type for this map     *         (optional)     * @throws NullPointerException if function or a replacement value is null,     *         and this map does not permit null keys or values     *         (optional)     * @throws IllegalArgumentException if some property of a replacement value     *         prevents it from being stored in this map     *         (optional)     * @throws ConcurrentModificationException if an entry is found to be     * removed during iteration     * @since 1.8     */    default void replaceAll(BiFunction
         function) {        Objects.requireNonNull(function);        for (Map.Entry
        
          entry : entrySet()) {            K k;            V v;            try {                k = entry.getKey();                v = entry.getValue();            } catch(IllegalStateException ise) {                // this usually means the entry is no longer in the map.                throw new ConcurrentModificationException(ise);            }            // ise thrown from function is not a cme.            v = function.apply(k, v);            try {                entry.setValue(v);            } catch(IllegalStateException ise) {                // this usually means the entry is no longer in the map.                throw new ConcurrentModificationException(ise);            }        }    }    /**     * If the specified key is not already associated with a value (or is mapped     * to {
     @code null}) associates it with the given value and returns     * {
     @code null}, else returns the current value.     *     * @implSpec     * The default implementation is equivalent to, for this {
     @code     * map}:     *     * 
        
       
 {
     @code     * V v = map.get(key);     * if (v == null)     *     v = map.put(key, value);     *     * return v;     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.     *     * @param key key with which the specified value is to be associated     * @param value value to be associated with the specified key     * @return the previous value associated with the specified key, or     *         {
     @code null} if there was no mapping for the key.     *         (A {
     @code null} return can also indicate that the map     *         previously associated {
     @code null} with the key,     *         if the implementation supports null values.)     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the key or value is of an inappropriate     *         type for this map     *         (optional)     * @throws NullPointerException if the specified key or value is null,     *         and this map does not permit null keys or values     *         (optional)     * @throws IllegalArgumentException if some property of the specified key     *         or value prevents it from being stored in this map     *         (optional)     * @since 1.8     */    default V putIfAbsent(K key, V value) {        V v = get(key);        if (v == null) {            v = put(key, value);        }        return v;    }    /**     * Removes the entry for the specified key only if it is currently     * mapped to the specified value.     *     * @implSpec     * The default implementation is equivalent to, for this {
     @code map}:     *     * 
       
 {
     @code     * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {     *     map.remove(key);     *     return true;     * } else     *     return false;     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.     *     * @param key key with which the specified value is associated     * @param value value expected to be associated with the specified key     * @return {
     @code true} if the value was removed     * @throws UnsupportedOperationException if the {
     @code remove} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the key or value is of an inappropriate     *         type for this map     *         (optional)     * @throws NullPointerException if the specified key or value is null,     *         and this map does not permit null keys or values     *         (optional)     * @since 1.8     */    default boolean remove(Object key, Object value) {        Object curValue = get(key);        if (!Objects.equals(curValue, value) ||            (curValue == null && !containsKey(key))) {            return false;        }        remove(key);        return true;    }    /**     * Replaces the entry for the specified key only if currently     * mapped to the specified value.     *     * @implSpec     * The default implementation is equivalent to, for this {
     @code map}:     *     * 
       
 {
     @code     * if (map.containsKey(key) && Objects.equals(map.get(key), value)) {     *     map.put(key, newValue);     *     return true;     * } else     *     return false;     * }
     *     * The default implementation does not throw NullPointerException     * for maps that do not support null values if oldValue is null unless     * newValue is also null.     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.     *     * @param key key with which the specified value is associated     * @param oldValue value expected to be associated with the specified key     * @param newValue value to be associated with the specified key     * @return {
     @code true} if the value was replaced     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of a specified key or value     *         prevents it from being stored in this map     * @throws NullPointerException if a specified key or newValue is null,     *         and this map does not permit null keys or values     * @throws NullPointerException if oldValue is null and this map does not     *         permit null values     *         (optional)     * @throws IllegalArgumentException if some property of a specified key     *         or value prevents it from being stored in this map     * @since 1.8     */    default boolean replace(K key, V oldValue, V newValue) {        Object curValue = get(key);        if (!Objects.equals(curValue, oldValue) ||            (curValue == null && !containsKey(key))) {            return false;        }        put(key, newValue);        return true;    }    /**     * Replaces the entry for the specified key only if it is     * currently mapped to some value.     *     * @implSpec     * The default implementation is equivalent to, for this {
     @code map}:     *     * 
       
 {
     @code     * if (map.containsKey(key)) {     *     return map.put(key, value);     * } else     *     return null;     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties.      *     * @param key key with which the specified value is associated     * @param value value to be associated with the specified key     * @return the previous value associated with the specified key, or     *         {
     @code null} if there was no mapping for the key.     *         (A {
     @code null} return can also indicate that the map     *         previously associated {
     @code null} with the key,     *         if the implementation supports null values.)     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     *         (optional)     * @throws NullPointerException if the specified key or value is null,     *         and this map does not permit null keys or values     * @throws IllegalArgumentException if some property of the specified key     *         or value prevents it from being stored in this map     * @since 1.8     */    default V replace(K key, V value) {        V curValue;        if (((curValue = get(key)) != null) || containsKey(key)) {            curValue = put(key, value);        }        return curValue;    }    /**     * If the specified key is not already associated with a value (or is mapped     * to {
     @code null}), attempts to compute its value using the given mapping     * function and enters it into this map unless {
     @code null}.     *     * 
       
If the function returns {
     @code null} no mapping is recorded. If     * the function itself throws an (unchecked) exception, the     * exception is rethrown, and no mapping is recorded.  The most     * common usage is to construct a new object serving as an initial     * mapped value or memoized result, as in:     *     * 
       
 {
     @code     * map.computeIfAbsent(key, k -> new Value(f(k)));     * }
     *     * 
       
Or to implement a multi-value map, {
     @code Map
        
         
          >},     * supporting multiple values per key:     *     * 
         
        
       
 {
     @code     * map.computeIfAbsent(key, k -> new HashSet
        
         ()).add(v);     * }
        
     *     *     * @implSpec     * The default implementation is equivalent to the following steps for this     * {
     @code map}, then returning the current value or {
     @code null} if now     * absent:     *     * 
       
 {
     @code     * if (map.get(key) == null) {     *     V newValue = mappingFunction.apply(key);     *     if (newValue != null)     *         map.put(key, newValue);     * }     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties. In particular, all implementations of     * subinterface {
     @link java.util.concurrent.ConcurrentMap} must document     * whether the function is applied once atomically only if the value is not     * present.     *     * @param key key with which the specified value is to be associated     * @param mappingFunction the function to compute a value     * @return the current (existing or computed) value associated with     *         the specified key, or null if the computed value is null     * @throws NullPointerException if the specified key is null and     *         this map does not support null keys, or the mappingFunction     *         is null     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     *         (optional)     * @since 1.8     */    default V computeIfAbsent(K key,            Function
         mappingFunction) {        Objects.requireNonNull(mappingFunction);        V v;        if ((v = get(key)) == null) {            V newValue;            if ((newValue = mappingFunction.apply(key)) != null) {                put(key, newValue);                return newValue;            }        }        return v;    }    /**     * If the value for the specified key is present and non-null, attempts to     * compute a new mapping given the key and its current mapped value.     *     * 
       
If the function returns {
     @code null}, the mapping is removed.  If the     * function itself throws an (unchecked) exception, the exception is     * rethrown, and the current mapping is left unchanged.    *     * @implSpec     * The default implementation is equivalent to performing the following     * steps for this {
     @code map}, then returning the current value or     * {
     @code null} if now absent:     *     * 
       
 {
     @code     * if (map.get(key) != null) {     *     V oldValue = map.get(key);     *     V newValue = remappingFunction.apply(key, oldValue);     *     if (newValue != null)     *         map.put(key, newValue);     *     else     *         map.remove(key);     * }     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties. In particular, all implementations of     * subinterface {
     @link java.util.concurrent.ConcurrentMap} must document     * whether the function is applied once atomically only if the value is not     * present.     *     * @param key key with which the specified value is to be associated     * @param remappingFunction the function to compute a value     * @return the new value associated with the specified key, or null if none     * @throws NullPointerException if the specified key is null and     *         this map does not support null keys, or the     *         remappingFunction is null     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     *         (optional)     * @since 1.8     */    default V computeIfPresent(K key,            BiFunction
         remappingFunction) {        Objects.requireNonNull(remappingFunction);        V oldValue;        if ((oldValue = get(key)) != null) {            V newValue = remappingFunction.apply(key, oldValue);            if (newValue != null) {                put(key, newValue);                return newValue;            } else {                remove(key);                return null;            }        } else {            return null;        }    }    /**     * Attempts to compute a mapping for the specified key and its current     * mapped value (or {
     @code null} if there is no current mapping). For     * example, to either create or append a {
     @code String} msg to a value     * mapping:     *     * 
       
 {
     @code     * map.compute(key, (k, v) -> (v == null) ? msg : v.concat(msg))}
     * (Method {
     @link #merge merge()} is often simpler to use for such purposes.)     *     * 
       
If the function returns {
     @code null}, the mapping is removed (or     * remains absent if initially absent).  If the function itself throws an     * (unchecked) exception, the exception is rethrown, and the current mapping     * is left unchanged.     *     * @implSpec     * The default implementation is equivalent to performing the following     * steps for this {
     @code map}, then returning the current value or     * {
     @code null} if absent:     *     * 
       
 {
     @code     * V oldValue = map.get(key);     * V newValue = remappingFunction.apply(key, oldValue);     * if (oldValue != null ) {     *    if (newValue != null)     *       map.put(key, newValue);     *    else     *       map.remove(key);     * } else {     *    if (newValue != null)     *       map.put(key, newValue);     *    else     *       return null;     * }     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties. In particular, all implementations of     * subinterface {
     @link java.util.concurrent.ConcurrentMap} must document     * whether the function is applied once atomically only if the value is not     * present.     *     * @param key key with which the specified value is to be associated     * @param remappingFunction the function to compute a value     * @return the new value associated with the specified key, or null if none     * @throws NullPointerException if the specified key is null and     *         this map does not support null keys, or the     *         remappingFunction is null     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     *         (optional)     * @since 1.8     */    default V compute(K key,            BiFunction
         remappingFunction) {        Objects.requireNonNull(remappingFunction);        V oldValue = get(key);        V newValue = remappingFunction.apply(key, oldValue);        if (newValue == null) {            // delete mapping            if (oldValue != null || containsKey(key)) {                // something to remove                remove(key);                return null;            } else {                // nothing to do. Leave things as they were.                return null;            }        } else {            // add or replace old mapping            put(key, newValue);            return newValue;        }    }    /**     * If the specified key is not already associated with a value or is     * associated with null, associates it with the given non-null value.     * Otherwise, replaces the associated value with the results of the given     * remapping function, or removes if the result is {
     @code null}. This     * method may be of use when combining multiple mapped values for a key.     * For example, to either create or append a {
     @code String msg} to a     * value mapping:     *     * 
       
 {
     @code     * map.merge(key, msg, String::concat)     * }
     *     * 
       
If the function returns {
     @code null} the mapping is removed.  If the     * function itself throws an (unchecked) exception, the exception is     * rethrown, and the current mapping is left unchanged.     *     * @implSpec     * The default implementation is equivalent to performing the following     * steps for this {
     @code map}, then returning the current value or     * {
     @code null} if absent:     *     * 
       
 {
     @code     * V oldValue = map.get(key);     * V newValue = (oldValue == null) ? value :     *              remappingFunction.apply(oldValue, value);     * if (newValue == null)     *     map.remove(key);     * else     *     map.put(key, newValue);     * }
     *     * 
       
The default implementation makes no guarantees about synchronization     * or atomicity properties of this method. Any implementation providing     * atomicity guarantees must override this method and document its     * concurrency properties. In particular, all implementations of     * subinterface {
     @link java.util.concurrent.ConcurrentMap} must document     * whether the function is applied once atomically only if the value is not     * present.     *     * @param key key with which the resulting value is to be associated     * @param value the non-null value to be merged with the existing value     *        associated with the key or, if no existing value or a null value     *        is associated with the key, to be associated with the key     * @param remappingFunction the function to recompute a value if present     * @return the new value associated with the specified key, or null if no     *         value is associated with the key     * @throws UnsupportedOperationException if the {
     @code put} operation     *         is not supported by this map     *         (optional)     * @throws ClassCastException if the class of the specified key or value     *         prevents it from being stored in this map     *         (optional)     * @throws NullPointerException if the specified key is null and this map     *         does not support null keys or the value or remappingFunction is     *         null     * @since 1.8     */    default V merge(K key, V value,            BiFunction
         remappingFunction) {        Objects.requireNonNull(remappingFunction);        Objects.requireNonNull(value);        V oldValue = get(key);        V newValue = (oldValue == null) ? value :                   remappingFunction.apply(oldValue, value);        if(newValue == null) {            remove(key);        } else {            put(key, newValue);        }        return newValue;    }}
      

我们再点击开HashMap的源码，我们可以看到HashMap继承了AbstractMap<K,V>，同时实现了Map<K,V>, Cloneable, Serializable。

public class HashMap
      
        extends AbstractMap
       
            implements Map
        
         , Cloneable, Serializable
        
       
      

我们再点击开AbstractMap的源码，我会惊奇的发现了，AbstractMap已经实现了Map接口，那么为什么HashMap还有再次实现Map接口呢？如果有人问你这个问题，你就打死他，百度了很多资料，据说是当时开发人员写多了，比较悲催。

public abstract class AbstractMap
     
       implements Map
      
     

我们接着回到HashMap的源码中，我们在236行看到 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 也就是说一个map在无参数的情况下被创建出来，默认的大小就是 1<<4 （16）

在248行我们可以看到DEFAULT_LOAD_FACTOR 默认负载因子 0.75， 这个非常重要，在后面的扩容会用到。

HashMap 提供了4个构造方法，可以接收修改初始化大小和负载因子，但是一般情况下就不要去修改了，避免设置得不好性能上出现问题。

MAXIMUM_CAPACITY 最大容量 1 << 30。1左移30位二进制的形势下就是 0100 0000 0000 0000 0000 0000 0000 0000，这个的意思是2的30次方，十进制下是 1073741824。注释说了 MUST be a power of two（一定要是2的n次方）， 再多移动一位 1<<31 就变成负数了。

TREEIFY_THRESHOLD，UNTREEIFY_THRESHOLD， MIN_TREEIFY_CAPACITY 这几个参数是后面当红黑树的参数。分别为最大阈值，取消阈值验证，和最小阈值。

我们再来看一下279行代码 static class Node<K,V> implements Map.Entry<K,V> 和396行的transient Node<K,V>[] table 这2个东西就是 HashMap 的本质了。读到这里，我们知道了，其实 HashMap 就是一个由 Node 类组成的一个二维数组，Node 是 Map.Entry 的具体实现类。当put一个对象的时候会根据对象的hash值计算出它在数组中存放的位置（通过扰动函数计算，后面会讲到），然后判断这个位置上有没有已经存在的对象，如果没有就直接放到这个位置，如果有将已存在对象的next指向当前对象形成一个链表，当链表长度超过一定数量之后，链表会转换成红黑树（这是java8之后的修改，为了提升查询效率）。所以hashmap本质上是一个二维数组加链表加红黑树的组合。

我们知道HashMap的内部结构了，那么我们来看一下他为什么是线程不安全的。我们在上述文章中，可以知道HashMap是链表结构的，也就是说总有一个指针指向下一项或上一项。

我们在声明HashMap时，使用的都是默认的构造方法：HashMap<K,V>，看了代码你会发现，它还有其它的构造方法：HashMap(int initialCapacity, float loadFactor)，

其中参数initialCapacity为初始容量，loadFactor为加载因子，扩容就是在put加入元素的个数超过initialCapacity * loadFactor的时候就会将内部Entry数组大小扩大至原来的2倍，然后将数组元素按照新的数组大小重新计算索引，放在新

的数组中，同时修改每个节点的链表关系（主要是next和节点在链表中的位置）。

概括的来说：HashMap在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。

HashTable就是因为加了synchronized线程锁，而不是因为他们的结构不一致才保证的线程安全，HashMap和HashTable都是单向链表结构的。

如果我们真的理解了上面所说的一切，我觉得面试官不会不满意你对于HashMap和Hashtable的面试答案吧，可能会问到一些扩展问题，不如，怎么才能做到线程安全，什么是扰动函数，红黑树又是什么？下面我来依依作答这些问题。

2、Q：怎么才能做到线程的安全。

　  A：首先我们应该知道什么是线程，线程thread是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程，但轻量进程更多指内核线程（kernel thread），而我们一般把用户线程（user thread）称为线程。

 　　　然后我们应该知道什么是多线程，提到多线程这里要说两个概念，就是串行和并行，搞清楚这个我们才能更好的理解多线程，串行是指，A、B、C三个任务，执行完任务A，才能执行B，B执行完，才能执行C，而并行是指三个任务一起执行。

　　　什么是线程安全，既然是线程安全问题，那么毫无疑问所有的隐患都是出现在多个线程访问的情况下产生的，也就是我们要确保在多条线程访问的时候，我们的程序还能按照我们预期的行为去执行。当多个线程访问某个方法时，不管你通过怎样的调用方式或者说这些线程如何交替的执行，我们在主程序中不需要去做任何的同步，这个类的结果行为都是我们设想的正确行为，那么我们就可以说这个类时线程安全的。那么我们来不如正题来说下java如何做到线程的安全，也可以理解为线程的同步。

　　  我们先来看一段代码：

package com;public class Demo {    static int tickets = 10;    class SellTickets implements Runnable {        @Override        public void run() {            // 未加同步时产生脏数据            while (tickets > 0) {                System.out.println(Thread.currentThread().getName() + "--->售出第：  " + tickets + " 票");                tickets--;                try {                    Thread.sleep(1000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            if (tickets <= 0) {                System.out.println(Thread.currentThread().getName() + "--->售票结束！");            }        }    }    public static void main(String[] args) {        SellTickets sell = new Demo().new SellTickets();        Thread thread1 = new Thread(sell, "1号窗口");        Thread thread2 = new Thread(sell, "2号窗口");        Thread thread3 = new Thread(sell, "3号窗口");        Thread thread4 = new Thread(sell, "4号窗口");        thread1.start();        thread2.start();        thread3.start();        thread4.start();    }}

我运行可以发现，有重复售票的情况，那么说明现在的方式是不安全的，我们可以采用以下方法来控制线程的安全。

　　  第一种实现线程安全的方式，同步代码块

这样我们就可以保证线程的一致性了。

　　第二种方式Lock锁机制， 通过创建Lock对象，采用lock()加锁，unlock()解锁，来保护指定的代码块

 

package com;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;public class Demo {    static int tickets = 10;    class SellTickets implements Runnable {        Lock lock = new ReentrantLock();        @Override        public void run() {            // Lock锁机制            while (tickets > 0) {                try {                    lock.lock();                    if (tickets <= 0) {                        return;                    }                    System.out.println(Thread.currentThread().getName() + "--->售出第：  " + tickets + " 票");                    tickets--;                } catch (Exception e1) {                    // TODO Auto-generated catch block                    e1.printStackTrace();                } finally {                    lock.unlock();                    try {                        Thread.sleep(100);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }            if (tickets <= 0) {                System.out.println(Thread.currentThread().getName() + "--->售票结束！");            }        }    }    public static void main(String[] args) {        SellTickets sell = new Demo().new SellTickets();        Thread thread1 = new Thread(sell, "1号窗口");        Thread thread2 = new Thread(sell, "2号窗口");        Thread thread3 = new Thread(sell, "3号窗口");        Thread thread4 = new Thread(sell, "4号窗口");        thread1.start();        thread2.start();        thread3.start();        thread4.start();    }}

总结：由于synchronized是在JVM层面实现的，因此系统可以监控锁的释放与否；而ReentrantLock是使用代码实现的，系统无法自动释放锁，需要在代码中的finally子句中显式释放锁lock.unlock()。另外，在并发量比较小的情况下，使用synchronized是个不错的选择；但是在并发量比较高的情况下，其性能下降会很严重，此时ReentrantLock是个不错的方案。

补充：在使用synchronized 代码块时,可以与wait()、notify()、nitifyAll()一起使用，从而进一步实现线程的通信。其中，wait()方法会释放占有的对象锁，当前线程进入等待池，释放cpu,而其他正在等待的线程即可抢占此锁，获得锁的线程即可运行程序；线程的sleep()方法则表示，当前线程会休眠一段时间，休眠期间，会暂时释放cpu，但并不释放对象锁，也就是说，在休眠期间，其他线程依然无法进入被同步保护的代码内部，当前线程休眠结束时，会重新获得cpu执行权,从而执行被同步保护的代码。wait()和sleep()最大的不同在于wait()会释放对象锁，而sleep()不会释放对象锁。notify()方法会唤醒因为调用对象的wait()而处于等待状态的线程，从而使得该线程有机会获取对象锁。调用notify()后，当前线程并不会立即释放锁，而是继续执行当前代码，直到synchronized中的代码全部执行完毕，才会释放对象锁。JVM会在等待的线程中调度一个线程去获得对象锁，执行代码。需要注意的是，wait()和notify()必须在synchronized代码块中调用。notifyAll()是唤醒所有等待的线程。

　　说了这么多，其实就是一个由Map引发的“血案”，其实还有很多很多的扩展问题。明天我们再来继续讨论这些问题。